// 15_standard_library_functions.rs
// 演示 Rust 中常用的标准库函数与实用宏

// 导入需要的模块
use std::collections::{HashMap, HashSet, BTreeMap, BTreeSet};
use std::env;
use std::fs;
use std::io::{self, Write};
use std::ops::{Add, Mul};
use std::process;
use std::sync::{Arc, Mutex};
use std::thread;
use std::time::Duration;

// 将原来的 main 函数改为公共的 run 函数
pub fn run() {
    // 1. 常用宏
    println!("=== 常用宏 ===");
    
    // println! - 打印格式化字符串到标准输出
    println!("Hello, Rust!");
    println!("{} + {} = {}", 2, 3, 2 + 3);
    
    // dbg! - 打印表达式的值和位置信息，用于调试
    let a = 5;
    let b = dbg!(a * 2); // 这会打印调试信息并返回表达式的值
    
    // format! - 创建格式化的字符串
    let formatted = format!("{}, {}!", "Hello", "world");
    println!("格式化后的字符串: {}", formatted);
    
    // panic! - 引发 panic，用于不可恢复的错误
    // panic!("发生了错误！"); // 取消注释这行会导致程序崩溃
    
    // vec! - 创建向量
    let v = vec![1, 2, 3, 4, 5];
    println!("向量: {:?}", v);
    
    // Ok! 和 Err! - 创建 Result 类型的快捷方式
    let result: Result<i32, &str> = Ok!(42);
    let error: Result<i32, &str> = Err!("出错了");
    
    // Some! 和 None! - 创建 Option 类型的快捷方式（Rust 1.64+）
    let some_value: Option<i32> = Some!(10);
    let none_value: Option<i32> = None!();
    
    // 2. 常用集合操作
    println!("\n=== 常用集合操作 ===");
    
    // Vec 操作
    let mut vec = Vec::new();
    vec.push(1);
    vec.push(2);
    vec.push(3);
    println!("向量长度: {}", vec.len());
    println!("向量是否为空: {}", vec.is_empty());
    println!("向量是否包含 2: {}", vec.contains(&2));
    
    // 遍历向量
    println!("遍历向量:");
    for item in &vec {
        print!("{} ", item);
    }
    println!();
    
    // HashMap 操作
    let mut map = HashMap::new();
    map.insert("one", 1);
    map.insert("two", 2);
    map.insert("three", 3);
    
    println!("HashMap 是否包含 'two': {}", map.contains_key(&"two"));
    println!("'two' 对应的值: {:?}", map.get(&"two"));
    
    // 遍历 HashMap
    println!("遍历 HashMap:");
    for (key, value) in &map {
        println!("{}: {}", key, value);
    }
    
    // HashSet 操作
    let mut set = HashSet::new();
    set.insert(1);
    set.insert(2);
    set.insert(3);
    set.insert(2); // 重复元素，不会被插入
    
    println!("HashSet 大小: {}", set.len());
    println!("HashSet 是否包含 2: {}", set.contains(&2));
    
    // 3. 字符串操作
    println!("\n=== 字符串操作 ===");
    
    // String 操作
    let mut s = String::from("hello");
    s.push(' ');
    s.push_str("world");
    println!("字符串: {}", s);
    println!("字符串长度: {}", s.len());
    println!("字符串是否为空: {}", s.is_empty());
    
    // 字符串切片操作
    let slice = &s[0..5];
    println!("字符串切片: {}", slice);
    
    // 字符串查找
    println!("字符串是否包含 'world': {}", s.contains("world"));
    println!("字符串以 'hello' 开头: {}", s.starts_with("hello"));
    println!("字符串以 'world' 结尾: {}", s.ends_with("world"));
    
    // 字符串分割
    println!("分割字符串:");
    for word in s.split_whitespace() {
        println!("{}", word);
    }
    
    // 4. 错误处理函数
    println!("\n=== 错误处理函数 ===");
    
    // unwrap - 从 Result 或 Option 中获取值，如果是错误或 None 则 panic
    let ok_result: Result<i32, &str> = Ok(42);
    let value = ok_result.unwrap();
    println!("unwrap 结果: {}", value);
    
    // expect - 类似于 unwrap，但可以提供自定义的错误信息
    let result_with_msg = ok_result.expect("应该有值");
    println!("expect 结果: {}", result_with_msg);
    
    // unwrap_or - 从 Option 中获取值，如果是 None 则返回默认值
    let some = Some(5);
    let none: Option<i32> = None;
    println!("unwrap_or 有值: {}", some.unwrap_or(0));
    println!("unwrap_or 无值: {}", none.unwrap_or(0));
    
    // unwrap_or_else - 从 Option 中获取值，如果是 None 则通过闭包计算默认值
    println!("unwrap_or_else 无值: {}", none.unwrap_or_else(|| 10));
    
    // 5. 数值操作
    println!("\n=== 数值操作 ===");
    
    // 整数操作
    let x = 42;
    println!("42 的绝对值: {}", x.abs());
    println!("42 的二进制表示: {:b}", x);
    println!("42 的八进制表示: {:o}", x);
    println!("42 的十六进制表示: {:x}", x);
    
    // 浮点数操作
    let y = 3.14;
    println!("3.14 的绝对值: {}", y.abs());
    println!("3.14 的平方根: {}", y.sqrt());
    println!("3.14 的上取整: {}", y.ceil());
    println!("3.14 的下取整: {}", y.floor());
    println!("3.14 的四舍五入: {}", y.round());
    
    // 6. 时间操作
    println!("\n=== 时间操作 ===");
    
    // 睡眠
    println!("睡眠 1 秒...");
    thread::sleep(Duration::from_secs(1));
    println!("醒来了！");
    
    // 获取当前时间
    let now = std::time::SystemTime::now();
    println!("当前时间: {:?}", now);
    
    // 7. 文件操作
    println!("\n=== 文件操作 ===");
    
    // 创建目录（如果不存在）
    if let Err(e) = fs::create_dir("temp") {
        println!("创建目录失败: {}, 可能已经存在", e);
    }
    
    // 写入文件
    if let Err(e) = fs::write("temp/hello.txt", "Hello, Rust!") {
        println!("写入文件失败: {}", e);
    } else {
        println!("写入文件成功");
    }
    
    // 读取文件
    match fs::read_to_string("temp/hello.txt") {
        Ok(content) => println!("读取文件内容: {}", content),
        Err(e) => println!("读取文件失败: {}", e),
    }
    
    // 列出目录内容
    match fs::read_dir(".") {
        Ok(entries) => {
            println!("当前目录内容:");
            for entry in entries {
                if let Ok(entry) = entry {
                    println!("{:?}", entry.path());
                }
            }
        },
        Err(e) => println!("读取目录失败: {}", e),
    }
    
    // 8. 路径操作
    println!("\n=== 路径操作 ===");
    
    let path = std::path::Path::new("temp/hello.txt");
    println!("路径存在: {}", path.exists());
    println!("是文件: {}", path.is_file());
    println!("是目录: {}", path.is_dir());
    println!("文件名: {:?}", path.file_name());
    println!("扩展名: {:?}", path.extension());
    
    // 9. 命令行参数
    println!("\n=== 命令行参数 ===");
    
    let args: Vec<String> = env::args().collect();
    println!("命令行参数数量: {}", args.len());
    println!("命令行参数: {:?}", args);
    
    // 10. 环境变量
    println!("\n=== 环境变量 ===");
    
    // 读取环境变量
    if let Ok(path) = env::var("PATH") {
        println!("PATH 环境变量长度: {}", path.len());
    }
    
    // 设置环境变量
    if let Err(e) = env::set_var("MY_CUSTOM_VAR", "custom_value") {
        println!("设置环境变量失败: {}", e);
    }
    
    // 11. 进程操作
    println!("\n=== 进程操作 ===");
    
    // 获取当前进程 ID
    println!("当前进程 ID: {}", process::id());
    
    // 注意：以下代码会执行外部命令，可能需要根据操作系统调整
    // 这里我们只是展示语法
    /*
    match process::Command::new("echo")
        .arg("Hello from child process")
        .output()
    {
        Ok(output) => {
            if let Ok(stdout) = String::from_utf8(output.stdout) {
                println!("子进程输出: {}", stdout);
            }
        },
        Err(e) => println!("执行命令失败: {}", e),
    }
    */
    
    // 12. 线程操作
    println!("\n=== 线程操作 ===");
    
    // 创建线程
    let handle = thread::spawn(|| {
        for i in 1..10 {
            println!("子线程: {}", i);
            thread::sleep(Duration::from_millis(100));
        }
    });
    
    // 主线程继续执行
    for i in 1..5 {
        println!("主线程: {}", i);
        thread::sleep(Duration::from_millis(200));
    }
    
    // 等待子线程完成
    handle.join().unwrap();
    
    // 使用 Arc 和 Mutex 在线程间共享可变数据
    let counter = Arc::new(Mutex::new(0));
    let mut handles = vec![];
    
    for _ in 0..10 {
        let counter = Arc::clone(&counter);
        let handle = thread::spawn(move || {
            let mut num = counter.lock().unwrap();
            *num += 1;
        });
        handles.push(handle);
    }
    
    for handle in handles {
        handle.join().unwrap();
    }
    
    println!("计数器值: {}", *counter.lock().unwrap());
    
    // 13. 迭代器操作
    println!("\n=== 迭代器操作 ===");
    
    let numbers = vec![1, 2, 3, 4, 5];
    
    // map - 对每个元素应用函数
    let doubled: Vec<_> = numbers.iter().map(|x| x * 2).collect();
    println!("每个元素翻倍: {:?}", doubled);
    
    // filter - 根据条件过滤元素
    let even: Vec<_> = numbers.iter().filter(|x| *x % 2 == 0).collect();
    println!("偶数元素: {:?}", even);
    
    // fold - 累积计算
    let sum: i32 = numbers.iter().fold(0, |acc, x| acc + x);
    println!("元素总和: {}", sum);
    
    // any - 检查是否有任何元素满足条件
    let has_even = numbers.iter().any(|x| *x % 2 == 0);
    println!("是否有偶数: {}", has_even);
    
    // all - 检查是否所有元素都满足条件
    let all_positive = numbers.iter().all(|x| *x > 0);
    println!("是否所有元素都是正数: {}", all_positive);
    
    // 14. 运算符重载和 Trait 实现
    println!("\n=== 运算符重载和 Trait 实现 ===");
    
    let point1 = Point { x: 1, y: 2 };
    let point2 = Point { x: 3, y: 4 };
    let point3 = point1 + point2;
    println!("点1 + 点2 = {:?}", point3);
    
    let point4 = point1 * 2;
    println!("点1 * 2 = {:?}", point4);
    
    // 15. 格式化输出
    println!("\n=== 格式化输出 ===");
    
    // 基本格式化
    println!("整数: {}", 42);
    println!("浮点数: {}", 3.14);
    println!("字符串: {}", "hello");
    
    // 宽度和精度
    println!("宽度为10的整数: {:10}", 42);
    println!("精度为2的浮点数: {:.2}", 3.14159);
    println!("宽度为10，精度为2的浮点数: {:10.2}", 3.14159);
    
    // 对齐
    println!("左对齐: {:<10}", "left");
    println!("居中对齐: {:^10}", "center");
    println!("右对齐: {:>10}", "right");
    
    // 调试格式
    println!("调试格式: {:?}", vec![1, 2, 3]);
    println!("详细调试格式: {:#?}", vec![1, 2, 3]);
    
    // 16. 输入输出
    println!("\n=== 输入输出 ===");
    
    // 从标准输入读取
    println!("请输入一些内容（按Enter键继续）:");
    let mut input = String::new();
    if let Ok(_) = io::stdin().read_line(&mut input) {
        println!("你输入的是: {}", input.trim());
    }
    
    // 写入标准错误
    if let Err(e) = writeln!(io::stderr(), "这是一条错误信息") {
        println!("写入错误信息失败: {}", e);
    }
    
    println!("\n标准库函数和宏示例演示完成！");
    println!("Rust 的标准库提供了丰富的功能，可以满足大多数编程需求");
    println!("使用 'std::prelude::v1::*' 可以自动导入最常用的标准库项");
    println!("查阅官方文档以了解更多标准库函数和宏: https://doc.rust-lang.org/std/");
}

// 用于演示运算符重载的结构体
#[derive(Debug)]
struct Point {
    x: i32,
    y: i32,
}

// 实现 Add Trait 用于加法运算
impl Add for Point {
    type Output = Point;
    
    fn add(self, other: Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

// 实现 Mul<u32> Trait 用于与整数相乘
impl Mul<u32> for Point {
    type Output = Point;
    
    fn mul(self, rhs: u32) -> Point {
        Point {
            x: self.x * rhs as i32,
            y: self.y * rhs as i32,
        }
    }
}